const app = getApp();
const nameMessages = require('../../utils/nameGenerationMessages.js');

Page({
  data: {
    expectation: '',
    // 参考寄语列表
    referenceExpectations: [
      '心胸豁达，积极乐观',
      '聪明伶俐，学业有成',
      '健康平安，幸福快乐',
      '温文尔雅，谦和有礼',
      '才华横溢，前程似锦',
      '勇敢坚强，乐观向上',
      '品德高尚，善良正直',
      '胸怀宽广，成就卓越'
    ],
    selectedReferences: [], // 存储已选择的参考寄语
    allusions: [], // 存储查询到的典故
    showAllusions: false, // 控制典故展示区域的显示
    isLoading: false, // 加载状态
    optimizedExpectation: '', // 存储优化后的期望描述
    isGeneratingName: false, // 控制生成名字的加载状态
    namesNum: 2 // 默认为双字名
  },

  onLoad: function() {
    // 页面加载时的逻辑
  },

  // 处理输入变化
  handleInput: function(e) {
    const text = e.detail.value;
    this.setData({
      expectation: text
    });
  },

  // 选择/取消选择参考寄语
  toggleReference: function(e) {
    const reference = e.currentTarget.dataset.reference;
    const selectedReferences = [...this.data.selectedReferences];
    
    // 检查是否已选择该寄语
    const index = selectedReferences.indexOf(reference);
    
    if (index === -1) {
      // 未选择，添加到已选列表
      if (selectedReferences.length >= 3) {
        wx.showToast({
          title: '最多选择3条寄语',
          icon: 'none',
          duration: 1500
        });
        return;
      }
      selectedReferences.push(reference);
    } else {
      // 已选择，从列表中移除
      selectedReferences.splice(index, 1);
    }
    
    // 更新已选参考寄语和输入框内容
    this.updateExpectation(selectedReferences);
  },
  
  // 更新期望寄语输入框内容
  updateExpectation: function(selectedReferences) {
    // 将所选寄语合并为一个字符串
    const combinedText = selectedReferences.join('、');
    
    this.setData({
      selectedReferences: selectedReferences,
      expectation: combinedText
    });
  },

  // 清空所有已选参考寄语
  clearSelected: function() {
    this.setData({
      selectedReferences: [],
      expectation: ''
    });
    
    wx.showToast({
      title: '已清空选择',
      icon: 'success',
      duration: 1000
    });
  },

  // 查询典故
  queryAllusions: function() {
    if (!this.data.expectation) {
      wx.showToast({
        title: '请输入您的期望',
        icon: 'none'
      });
      return;
    }

    this.setData({
      isLoading: true,
      showAllusions: false
    });

    // 显示初始加载提示框
    wx.showLoading({
      title: '正在查找典故...',
      mask: true
    });

    // 定义一系列递进式的提示消息
    const loadingMessages = [
      '正在分析您的期望...',
      '正在搜索古籍文献...',
      '已找到相关典故，正在整理中...',
      '正在筛选最适合的典故...',
      '即将完成，请再稍等片刻...'
    ];
    
    let messageIndex = 0;
    
    const showLoadingMessage = () => {
      // 先隐藏之前的提示
      try {
        wx.hideToast();
      } catch (e) {
        console.error('hideToast error:', e);
      }
      
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
      
      // 显示新的提示
      wx.showToast({
        title: loadingMessages[messageIndex],
        icon: 'none',
        duration: 10000,
        mask: true
      });
      
      // 更新消息索引，循环使用提示
      messageIndex = (messageIndex + 1) % loadingMessages.length;
    };

    // 3秒后显示第一次提示
    const firstTimer = setTimeout(() => {
      if (this.data.isLoading) {
        showLoadingMessage();
      }
    }, 3000);

    // 每5秒更新一次提示，直到请求完成
    const loadingInterval = setInterval(() => {
      if (this.data.isLoading) {
        showLoadingMessage();
      } else {
        clearInterval(loadingInterval);
      }
    }, 5000);

    // 调用API查询典故
    wx.request({
      url: 'https://api.coze.cn/v1/workflow/run',
      method: 'POST',
      header: {
        'Authorization': 'Bearer pat_0a0Ugs6FEC2g8bYXYFn2RN2IhGUXkq89gTnnTlxTlLEqAga1alunYAcdf1b9VqEG',
        'Content-Type': 'application/json'
      },
      data: {
        'workflow_id': '7480933438456512575',
        'parameters': {
          'unuse_allusion': '',
          'var_expect': this.data.expectation
        }
      },
      success: (res) => {
        if (res.data && res.data.code === 0) {
          try {
            // 解析返回数据
            const dataObj = JSON.parse(res.data.data);
            const outputObj = JSON.parse(dataObj.output);
            
            this.setData({
              allusions: outputObj.allusion || [],
              optimizedExpectation: outputObj.optimize_expect || '',
              showAllusions: true
            });

            // 显示成功提示
            wx.hideToast();
            wx.hideLoading();
            wx.showToast({
              title: '典故查找完成',
              icon: 'success',
              duration: 2000
            });
          } catch (error) {
            console.error('解析典故数据失败:', error);
            wx.hideToast();
            wx.hideLoading();
            wx.showToast({
              title: '数据格式不正确',
              icon: 'none',
              duration: 2000
            });
          }
        } else {
          console.error('API返回错误:', res.data);
          wx.hideToast();
          wx.hideLoading();
          wx.showToast({
            title: `查询失败: ${res.data.message || '未知错误'}`,
            icon: 'none',
            duration: 2000
          });
        }
      },
      fail: (err) => {
        console.error('请求失败:', err);
        wx.hideToast();
        wx.hideLoading();
        wx.showToast({
          title: '网络请求失败',
          icon: 'none',
          duration: 2000
        });
      },
      complete: () => {
        // 清除所有定时器
        clearTimeout(firstTimer);
        clearInterval(loadingInterval);
        
        // 确保隐藏所有 toast 和 loading
        try {
          wx.hideToast();
        } catch (e) {
          console.error('hideToast error:', e);
        }
        
        try {
          wx.hideLoading();
        } catch (e) {
          console.error('hideLoading error:', e);
        }
        
        this.setData({
          isLoading: false
        });
      }
    });
  },

  // 选择名字长度（单字/双字）
  selectNameLength: function(e) {
    const length = parseInt(e.currentTarget.dataset.length);
    this.setData({
      namesNum: length
    });
    
    wx.showToast({
      title: length === 1 ? '已选择单字名' : '已选择双字名',
      icon: 'none',
      duration: 1000
    });
  },

  // 提交期望
  submitExpectation: function() {
    if (!this.data.expectation || !this.data.showAllusions) {
      wx.showToast({
        title: '请先查找典故',
        icon: 'none'
      });
      return;
    }
    
    // 获取全局数据
    if (!app.globalData.birthInfo || !app.globalData.birthInfo.lastName || !app.globalData.birthInfo.gender) {
      wx.showToast({
        title: '请先完善出生信息',
        icon: 'none'
      });
      return;
    }

    // 将期望存储到全局数据
    app.globalData.expectation = this.data.expectation;
    
    // 提取典故中的quote，确保数据有效
    const allusions = Array.isArray(this.data.allusions) ? this.data.allusions.map(item => item.quote || '').filter(Boolean) : [];
    
    // 性别转换
    const sex = app.globalData.birthInfo.gender === 'male' ? '男' : '女';
    
    // 设置生成名字的加载状态
    this.setData({
      isGeneratingName: true
    });
    
    // 显示初始加载动画
    wx.showLoading({
      title: '正在推荐名字\n请耐心等待...',
      mask: true
    });
    
    // 使用通用的递进式提示消息
    const nameGenerationMessages = nameMessages.commonGenerationMessages;
    
    let nameMessageIndex = 0;
    
    const showNameGenerationMessage = () => {
      // 先隐藏之前的提示
      try {
        wx.hideToast();
      } catch (e) {
        console.error('hideToast error:', e);
      }
      
      try {
        wx.hideLoading();
      } catch (e) {
        console.error('hideLoading error:', e);
      }
      
      // 显示新的提示
      wx.showToast({
        title: nameGenerationMessages[nameMessageIndex],
        icon: 'none',
        duration: 10000,
        mask: true
      });
      
      // 更新消息索引，循环使用提示
      nameMessageIndex = (nameMessageIndex + 1) % nameGenerationMessages.length;
    };
    
    // 3秒后显示第一次提示
    const firstNameTimer = setTimeout(() => {
      if (this.data.isGeneratingName) {
        showNameGenerationMessage();
      }
    }, 3000);
    
    // 每4秒更新一次提示，直到请求完成
    const nameGenerationInterval = setInterval(() => {
      if (this.data.isGeneratingName) {
        showNameGenerationMessage();
      } else {
        clearInterval(nameGenerationInterval);
      }
    }, 4000);

    // 安全超时，确保不会永久卡在加载状态
    const safetyTimeout = setTimeout(() => {
      console.log('安全超时触发，强制重置生成状态');
      this.resetGeneratingState(firstNameTimer, nameGenerationInterval);
      wx.showToast({
        title: '请求超时，请重试',
        icon: 'none',
        duration: 2000
      });
    }, 95000); // 95秒超时保护，略长于API请求超时

    // 调用生成名字接口
    wx.request({
      url: 'https://api.coze.cn/v1/workflow/run',
      method: 'POST',
      timeout: 90000, // 将超时时间设置为90秒
      header: {
        'Authorization': 'Bearer pat_0a0Ugs6FEC2g8bYXYFn2RN2IhGUXkq89gTnnTlxTlLEqAga1alunYAcdf1b9VqEG',
        'Content-Type': 'application/json'
      },
      data: {
        'workflow_id': '7481267197018554402',
        'parameters': {
          'wuxing': '金木水火土',
          'lastname': app.globalData.birthInfo.lastName || '',
          'sex': sex,
          'allusion': allusions,
          'namesNum': this.data.namesNum,
          // 添加定字取名相关参数，从nameFormData获取
          'is_fixedname': app.globalData.nameFormData?.fixedChar || false,
          'fixedposition': app.globalData.nameFormData?.fixedPosition || 'first',
          'fixed_word': app.globalData.nameFormData?.fixedCharValue || ''
        }
      },
      success: (res) => {
        console.log('API请求成功返回:', res.data);
        clearTimeout(safetyTimeout); // 清除安全超时
        
        if (res.data && res.data.code === 0 && res.data.data) {
          try {
            // 保存完整的API响应数据到全局
            app.globalData.apiResponse = res.data;
            
            // 解析返回数据进行验证
            const dataObj = JSON.parse(res.data.data);
            const namesData = JSON.parse(dataObj.passNames || '[]');
            
            if (!Array.isArray(namesData) || namesData.length === 0) {
              throw new Error('未获取到有效的名字数据');
            }
            
            // 在导航前确保清除加载状态
            this.resetGeneratingState(firstNameTimer, nameGenerationInterval);
            
            // 成功提示后再跳转
            wx.hideToast();
            wx.hideLoading();
            wx.showToast({
              title: '名字生成成功',
              icon: 'success',
              duration: 1000,
              complete: () => {
                // 跳转到结果展示页
                setTimeout(() => {
                  wx.navigateTo({
                    url: '/pages/results/results',
                    events: {
                      // 可以在这里监听results页面发送的事件
                    },
                    success: function(res) {
                      // 通过eventChannel向被打开页面传送数据
                      res.eventChannel.emit('resultData', { 
                        namesData: app.globalData.apiResponse,
                        surname: app.globalData.birthInfo.lastName,
                        methodType: 'combined', // 设置方法类型
                        gender: app.globalData.birthInfo.gender,
                        // 传递定字取名参数
                        is_fixedname: app.globalData.nameFormData?.fixedChar || false,
                        fixedposition: app.globalData.nameFormData?.fixedPosition || 'first',
                        fixed_word: app.globalData.nameFormData?.fixedCharValue || ''
                      });
                      console.log('成功导航到results页面并传递数据');
                    },
                    fail: function(err) {
                      console.error('导航到results页面失败:', err);
                      wx.showToast({
                        title: '页面跳转失败',
                        icon: 'none'
                      });
                    }
                  });
                }, 1000);
              }
            });
          } catch (error) {
            console.error('解析名字数据失败:', error);
            this.resetGeneratingState(firstNameTimer, nameGenerationInterval);
            wx.hideToast();
            wx.hideLoading();
            wx.showToast({
              title: '数据格式不正确',
              icon: 'none',
              duration: 2000
            });
          }
        } else {
          console.error('API返回错误:', res.data);
          this.resetGeneratingState(firstNameTimer, nameGenerationInterval);
          wx.hideToast();
          wx.hideLoading();
          wx.showToast({
            title: `生成名字失败: ${res.data?.message || '未知错误'}`,
            icon: 'none',
            duration: 2000
          });
        }
      },
      fail: (err) => {
        console.error('请求失败:', err);
        clearTimeout(safetyTimeout); // 清除安全超时
        this.resetGeneratingState(firstNameTimer, nameGenerationInterval);
        wx.hideToast();
        wx.hideLoading();
        wx.showToast({
          title: '网络请求失败',
          icon: 'none',
          duration: 2000
        });
      },
      complete: () => {
        clearTimeout(safetyTimeout); // 确保清除安全超时
        
        // 清除所有定时器
        this.resetGeneratingState(firstNameTimer, nameGenerationInterval);
        
        // 确保隐藏所有 toast 和 loading
        try {
          wx.hideToast();
        } catch (e) {
          console.error('hideToast error:', e);
        }
        
        try {
          wx.hideLoading();
        } catch (e) {
          console.error('hideLoading error:', e);
        }
      }
    });
  },

  // 添加重置生成状态的通用方法
  resetGeneratingState: function(timerRef, intervalRef) {
    // 清除定时器
    if (timerRef) clearTimeout(timerRef);
    if (intervalRef) clearInterval(intervalRef);
    
    // 重置状态
    this.setData({
      isGeneratingName: false
    });
    
    console.log('已重置名字生成状态');
  }
}) 